/*//裸类型   当数组的元素很多时，每一个元素都要强制类型转换就显得不方便了。
class MyArray{
    public Object[] array=new Object[10];
    public void setArray(int pos,Object x){
        array[pos]=x;
    }
    public Object getVal(int pos){
        return array[pos];
    }
}*/

class MyArray<T> {//在类的后面加上<>  ,<T>代表占位符，表示当前类是一个泛型类
    public Object[] array = new Object[10];

    public void setArray(int pos, T x) {
        array[pos] = x;
    }

    public T getVal(int pos) {
        return (T) array[pos];
    }
}
//定义一个泛型类，找到数组中最大值
class Alg<T extends Comparable<T>>{//表示传的泛型都是要实现Comparable接口的
    public T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
//            if(array[i]>max){//引用类型不能直接比较，会报错，要实现comparable接口比较
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
class Alg2{
    //泛型方法
    public<T extends Comparable <T>> T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
class Alg3{
    //泛型方法静态化 相较于泛型方法，只是加了static而已
    public static <T extends Comparable <T>> T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,2,3,4,5,6,7};
        Integer x =Alg3.findMax(array);//静态方法直接通过类名调用
        System.out.println(x);
    }
    public static void main4(String[] args) {
        Alg2 alg2 =new Alg2();
        Integer[] array={1,2,3,4,5,6,7};
//        Integer x =alg2.<Integer>findMax(array);
        Integer x =alg2.findMax(array);//不写<Integer>也行，编译器会通过前面来推导
        System.out.println(x);
    }
    public static void main3(String[] args) {
        Alg<Integer> alg=new Alg<>();
        Integer [] array={1,2,3,4,5,6,7};
        Integer x =alg.findMax(array);
        System.out.println(x);
    }
    public static void main2(String[] args) {
        //<Integer>代表传的数据类型是整形类型，
        // 后面的MyArray<>可以不写Integer，编译器会通过前面的推导，但是要加上<>
        MyArray<Integer> myArray=new MyArray<>();
        //只能写类 类型，不能写简单类型
        //MyArray<int> myArray=new MyArray<>();//err

        myArray.setArray(0,1);
        myArray.setArray(1,2);
        //编译的时候，每次存储x值，会检查是否是指定的数据类型，若不一样，会报错
//        myArray.setArray(1,"hello");
// 这里不需要进行强制类型转换，因为放数据的时候就进行了严格的检查
        Integer x= myArray.getVal(1);
        MyArray<String> myArray2=new MyArray<>();
        myArray2.setArray(0,"hewsa");

        System.out.println(myArray2.getVal(0));
    }

    public static void main1(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setArray(0, 1);
        myArray.setArray(1, 20);
        myArray.setArray(2, "hello");
        String s = (String) myArray.getVal(2);//getVal的返回类型是Object类，而接收的类型是String类型，要强制转换为String类型，否则会报错
        System.out.println(s);
    }
}

//public class MyArray1<E extends Number>{//表示参数是Number类或他的子类，
//
//}

